home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource3 / 104_01 / c5.c < prev    next >
Text File  |  1979-12-31  |  7KB  |  350 lines
  1.    
  2. /********************************************************/
  3. /*                            */
  4. /*    expression handler                 */
  5. /*                            */
  6. /*    table below show precedence of operator        */
  7. /*                            */
  8. /********************************************************/
  9. /*    operator    * routine    * associativity    */
  10. /********************************************************/
  11. /*    | ++ -- - * &    * heir10    * left to right    */
  12. /********************************************************/
  13. /*    * / %        * heir9        * rigth to left    */
  14. /********************************************************/
  15. /*    + -        * heir8        * left to right    */
  16. /********************************************************/
  17. /*    << >>        * heir7        * left to right    */
  18. /********************************************************/
  19. /*    < <= > >=    * heir6        * left to right    */
  20. /********************************************************/
  21. /*    == !=        * heir5        * left to rigth */
  22. /********************************************************/
  23. /*    &        * heir4        * left to rigth */
  24. /********************************************************/
  25. /*    ^        * heir3        * left to right */
  26. /********************************************************/
  27. /*    |        * heir2        * left to right */
  28. /********************************************************/
  29. /*    &&        * heir1e    * left to right */
  30. /********************************************************/
  31. /*    ||        * heir1d    * left to right */
  32. /********************************************************/
  33. /*    =  -= += *= %=  * heir1     * left to right */
  34. /*    /= &= ^= |=    *        *        */
  35. /********************************************************/
  36. #ifndef TRUE    /* check to see if need include file */
  37. #include <C.DEF>
  38. #endif
  39. expression()
  40. {
  41.         int lval[lvalsize],status;
  42.     status=FALSE;
  43.     rvalue(lval,heir1(lval,&status));
  44.     return status;
  45.     }
  46. heir1(lval,status)
  47. int lval[];
  48. int *status;
  49. {
  50.         int k;
  51.     char *ptr;
  52.         k=heir1d(lval,status);
  53.         if (ch() !=  '=' && nch() != '=') return k;
  54.     *status=FALSE;
  55.     switch(ch()) {
  56.  
  57.         /* just an equal */
  58.         case '=' :
  59.             gch();
  60.             equal(lval,k);
  61.             break;
  62.  
  63.         /* add value then store */
  64.         case '+' :
  65.         case '-' :
  66.             gch();gch();
  67.             equal_exp(lval,k);
  68.             size_adjust(lval);
  69.             if (ch() == '-') sub(); else add();
  70.             k=1;
  71.             break;
  72.  
  73.         case '*' :
  74.             gch();gch();
  75.             equal_exp(lval,k);
  76.             mult();
  77.             k=1;
  78.             break;
  79.  
  80.         case '/' :
  81.             gch();gch();
  82.             equal_exp(lval,k);
  83.             div();
  84.             k=1;
  85.             break;
  86.  
  87.  
  88.         case '%' :
  89.             gch();gch();
  90.             equal_exp(lval,k);
  91.             mod();
  92.             k=1;
  93.             break;
  94.  
  95.  
  96.         case '&' :
  97.             gch();gch();
  98.             equal_exp(lval,k);
  99.             and();
  100.             k=1;
  101.             break;
  102.  
  103.     
  104.         case '^' :
  105.             gch();gch();    
  106.             equal_exp(lval,k);
  107.             xor();
  108.             k=1;
  109.             break;
  110.         
  111.         case '|' :
  112.             gch();gch();
  113.             equal_exp(lval,k);
  114.             or();
  115.             k=1;
  116.             break;
  117.  
  118.         default:
  119.             return k;
  120.         }
  121.     store(lval,k);
  122.     return 0;
  123.     }
  124. /*                            */
  125. /*    written by Mike Bernson 1/81            */
  126. /*                            */
  127. heir1d(lval,status)
  128. int lval[];
  129. int *status;
  130. {
  131.     int k,lval2[lvalsize];
  132.     int label;
  133.     k=heir1e(lval,status);
  134.     blanks();
  135.     if (ch() != '|' || nch() != '|') return k;
  136.     rvalue(lval,k);
  137.     label=getlabel();
  138.     while(1) {
  139.         if (match("||")) {
  140.             truejump(label,*status);
  141.             *status=TRUE;
  142.             rvalue(lval2,heir1e(lval2,status));
  143.             }
  144.         else {
  145.             sprintlabel(label);
  146.             return 0;
  147.             }
  148.         }
  149.     }
  150. /*                    */
  151. /*    written by Mike Bernson 1/81    */
  152. /*                    */
  153. heir1e(lval,status)
  154. int lval[];
  155. int *status;
  156. {
  157.     int label;
  158.     int k,lval2[lvalsize];
  159.     k=heir2(lval,status);
  160.     blanks();
  161.     if (ch() != '&' || nch() != '&') return k;
  162.     rvalue(lval,k);
  163.     label=getlabel();
  164.     while(1) {
  165.         if (match("&&")) {
  166.             testjump(label,*status);
  167.             *status=TRUE;
  168.             rvalue(lval2,heir2(lval2,status));
  169.             }
  170.         else {
  171.             sprintlabel(label);
  172.             return 0;
  173.             }
  174.         }
  175.     }
  176. heir2(lval,status)
  177. int lval[];
  178. int *status;
  179. {
  180.     int k,lval2[lvalsize];
  181.     k=heir3(lval,status);
  182.     blanks();
  183.     if (ch() != '|' || nch() =='|' || nch()== '=') return k;
  184.     rvalue(lval,k);
  185.     while(1) {
  186.         if (match("|")) {
  187.             push();
  188.             rvalue(lval2,heir3(lval2,status));
  189.             or();
  190.             *status=TRUE;
  191.             }
  192.         else return 0;
  193.         }
  194.     }
  195. heir3(lval,status)
  196. int lval[];
  197. int *status;
  198. {
  199.     int k,lval2[lvalsize];
  200.      k=heir4(lval,status);
  201.     blanks();
  202.     if (ch() != '^' || nch() == '=') return k;
  203.     rvalue(lval,k);
  204.     while(1) {
  205.         if (match("^")) {
  206.             push();
  207.             rvalue(lval2,heir4(lval2,status));
  208.             xor();
  209.             *status=TRUE;
  210.             }
  211.         else return 0;
  212.         }
  213.     }
  214. heir4(lval,status)
  215. int lval[];
  216. int *status;
  217. {
  218.     int k,lval2[lvalsize];
  219.     k=heir5(lval,status);
  220.     blanks();
  221.     if (ch() != '&' || nch()=='&' || nch() == '=') return k;
  222.     rvalue(lval,k);
  223.     while(1) {
  224.         if (match("&")) {
  225.             push();
  226.             rvalue(lval2,heir5(lval2,status));
  227.             and();
  228.             *status=TRUE;
  229.             }
  230.         else return 0;
  231.         }
  232.     }
  233. heir5(lval,status)
  234. int lval[];
  235. int *status;
  236. {
  237.     int k,lval2[lvalsize];
  238.     k=heir6(lval,status);
  239.     blanks();
  240.     if ((streq(line+lptr,"==") ==0) &&
  241.                 (streq(line+lptr,"!=") == 0)) return k;
  242.         rvalue(lval,k);
  243.         while(1) {
  244.         if (match("==")) {
  245.             push();
  246.             rvalue(lval2,heir6(lval2,status));
  247.             eq();
  248.             *status=TRUE;
  249.             }
  250.         else if (match("!=")) {
  251.             push();
  252.             rvalue(lval2,heir6(lval2,status));
  253.             ne();
  254.             *status=TRUE;
  255.             }
  256.         else return 0;
  257.         }
  258.     }
  259. heir6(lval,status)
  260. int lval[];
  261. int *status;
  262. {
  263.     int k,lval2[lvalsize];
  264.     k=heir7(lval,status);
  265.     blanks();
  266.     if ((streq(line+lptr,"<") == 0) &&
  267.         (streq(line+lptr,">") == 0) &&
  268.         (streq(line+lptr,"<=") == 0) &&
  269.         (streq(line+lptr,">=") == 0)) return k;
  270.     if (streq(line+lptr,">>")) return k;
  271.     if (streq(line+lptr,"<<")) return k;
  272.     rvalue(lval,k);
  273.     while(1) {
  274.         if (match("<=")) {
  275.             push();
  276.             rvalue(lval2,heir7(lval2,status));
  277.             *status=TRUE;
  278.             if (cptr=lval[0])
  279.                 if(cptr[ident]==pointer) {
  280.                     ule();
  281.                     continue;
  282.                     }
  283.             if (cptr=lval2[0])
  284.                 if(cptr[ident]==pointer) {
  285.                     le();
  286.                     continue;
  287.                     }
  288.             le();
  289.             }
  290.         else if (match(">=")) {
  291.             push();
  292.             rvalue(lval2,heir7(lval2,status));
  293.             *status=TRUE;
  294.             if (cptr=lval[0])
  295.                 if (cptr[ident]==pointer) {
  296.                     uge();
  297.                     continue;
  298.                     }
  299.             if (cptr=lval2[0])
  300.                 if (cptr[ident]==pointer) {
  301.                     uge();
  302.                     continue;
  303.                     }
  304.             ge();
  305.             }
  306.         else if ((streq(line+lptr,"<")) &&
  307.             (streq(line+lptr,"<<")==0)) {
  308.                 inbyte();
  309.                 push();
  310.                 rvalue(lval2,heir7(lval2,status));
  311.                 *status=TRUE;
  312.                 if (cptr=lval[0])
  313.                     if (cptr[ident]==pointer) {
  314.                     ult();
  315.                     continue;
  316.                     }
  317.                 if(cptr=lval2[0])
  318.                     if (cptr[ident]==pointer) {
  319.                         ult();
  320.                         continue;
  321.                         }
  322.             lt();
  323.             }
  324.         else if ((streq(line+lptr,">")) &&
  325.             (streq(line+lptr,">>") == 0)) {
  326.                 inbyte();
  327.                 push();
  328.                 rvalue(lval2,heir7(lval2,status));
  329.                 *status=TRUE;
  330.             if (cptr=lval[0])
  331.                 if (cptr[ident]==pointer) {
  332.                     ugt();
  333.                     continue;
  334.                     }
  335.             if (cptr=lval2[0])
  336.                 if (cptr[ident]==pointer) {
  337.                     ugt();
  338.                     continue;
  339.                     }
  340.             gt();
  341.             }
  342.         else return 0;
  343.         }
  344.     }
  345. 
  346.     if (isbyte(k)) call("@stacks"); else call("@stackl");
  347.     defvalue(k);
  348.     return newsp;
  349.     }
  350. /*    Do